home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / xgui / sources / ui_selection.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  18.1 KB  |  645 lines
  1. /*****************************************************************************
  2.   FILE           : ui_selection.c
  3.   SHORTNAME      : select.c
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        :
  7.   NOTES          : UI_SELECTION_SIZE is no more in use! (defined in ui.h)
  8.  
  9.   AUTHOR         : Tilman Sommer
  10.   DATE           : 1.2.1990
  11.  
  12.   CHANGED BY     :
  13.   IDENTIFICATION : @(#)ui_selection.c    1.11 3/2/94
  14.   SCCS VERSION   : 1.11
  15.   LAST CHANGE    : 3/2/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.              
  19. ******************************************************************************/
  20.  
  21.  
  22. #include <stdio.h>
  23. #include <malloc.h>
  24.  
  25. #include "ui.h"
  26.  
  27. #include "kr_ui.h"
  28.  
  29. #include "ui_utilP.h"
  30. #include "ui_textP.h"
  31. #include "ui_status.h"
  32. #include "ui_display.h"
  33. #include "ui_netUpdate.h"
  34. #include "ui_confirmer.h"
  35. #include "ui_xGraphic.h"
  36. #include "ui_color.h"
  37. #include "ui_event.h"
  38. #include "ui_mainP.h"
  39.  
  40.  
  41. #include "ui_selection.ph"
  42.  
  43.  
  44. /*****************************************************************************
  45.   FUNCTION : ui_sel_msgNumber
  46.  
  47.   PURPOSE  : show the number of selected items
  48.   RETURNS  : alteration of the status message
  49.   NOTES    :
  50.  
  51.   UPDATE   :
  52. *****************************************************************************/
  53.  
  54. void ui_sel_msgNumber (void)
  55.  
  56. { 
  57.     ui_stat_displayStatus(ui_gridPosMouse);
  58. }
  59.  
  60.  
  61. /*****************************************************************************
  62.   FUNCTION : ui_sel_initSelectionList
  63.  
  64.   PURPOSE  : initialize the selection list and selection counters
  65.   RETURNS  : void
  66.   NOTES    :
  67.  
  68.   UPDATE   :
  69. *****************************************************************************/
  70.  
  71. void ui_sel_initSelectionList (void)
  72.  
  73. {
  74.     ui_sel_numberOfItems          = 0;
  75.     ui_sel_numberOfSelectedItems  = 0;
  76.     ui_sel_listPtr                = NULL;
  77.     ui_sel_freeListPtr            = NULL;
  78. }
  79.  
  80.  
  81. /*****************************************************************************
  82.   FUNCTION : ui_sel_createItem
  83.  
  84.   PURPOSE  : allocate size for one item from the heap and set default values
  85.   RETURNS  : pointer to that new item
  86.   NOTES    :
  87.  
  88.   UPDATE   :
  89. *****************************************************************************/
  90.  
  91. static struct SelectionType *ui_sel_createItem (void)
  92.  
  93. {
  94.     struct SelectionType  *selPtr;
  95.  
  96.     selPtr = (struct SelectionType *) malloc(sizeof(struct SelectionType));
  97.     if (selPtr != NULL) {
  98.     (*selPtr).unitNo     = 0;
  99.     (*selPtr).subNetNo   = 0;
  100.     (*selPtr).gridPos.x  = 0;
  101.     (*selPtr).gridPos.y  = 0;
  102.     (*selPtr).gridPos.z  = 0;
  103.     (*selPtr).flags      = UI_NO_FLAG;
  104.     (*selPtr).nextPtr    = NULL;
  105.     ui_sel_numberOfItems += 1;
  106.     }
  107.     return (selPtr);
  108. }
  109.  
  110.  
  111. /*****************************************************************************
  112.   FUNCTION : ui_sel_lookForItem
  113.  
  114.   PURPOSE  : look for an selected item with this no
  115.   RETURNS  : pointer to that item, if it was found, else NULL
  116.   NOTES    : By calling this routine it is garanteed that never two items
  117.              with the same position exist.
  118.  
  119.   UPDATE   :
  120. *****************************************************************************/
  121.  
  122. struct SelectionType *ui_sel_lookForItem (int unitNo)
  123.  
  124. {
  125.     struct SelectionType  *selPtr;
  126.  
  127.     selPtr = ui_sel_listPtr;
  128.     while ((selPtr != NULL) AND ((*selPtr).unitNo != unitNo))
  129.     selPtr = (*selPtr).nextPtr;
  130.     
  131.     if (selPtr != NULL)
  132.     if ((*selPtr).unitNo != unitNo)
  133.         /* there is no item at this position, set signal */
  134.         selPtr = NULL;
  135.  
  136.     return (selPtr);
  137. }
  138.  
  139.  
  140. /*****************************************************************************
  141.   FUNCTION : ui_sel_lookForSelectedItem
  142.  
  143.   PURPOSE  : search from the list item according to SelectionPtr until the end
  144.              of the list or a selected item was found.
  145.   RETURNS  : a pointer to this element or NULL, if no (more) elements are 
  146.              found.
  147.   NOTES    : 
  148.  
  149.   UPDATE   :
  150. *****************************************************************************/
  151.  
  152. struct SelectionType *ui_sel_lookForSelectedItem 
  153.                 (struct SelectionType *SelectionPtr)
  154.  
  155. {
  156.     struct SelectionType  *selPtr;
  157.  
  158.     selPtr = SelectionPtr;
  159.     while ((selPtr != NULL) AND 
  160.        (ui_utilIsNotSet((*selPtr).flags, UI_SELECTED)))
  161.     selPtr = (*selPtr).nextPtr;
  162.  
  163.     return (selPtr);
  164. }
  165.  
  166.  
  167. /*****************************************************************************
  168.   FUNCTION : ui_sel_freeItem
  169.  
  170.   PURPOSE  : links the item in the free list
  171.   RETURNS  : 
  172. *****************************************************************************/
  173.  
  174. static void ui_sel_freeItem (struct SelectionType *selectionPtr)
  175.  
  176. {
  177.     struct SelectionType  *selPtr;
  178.  
  179.     if (ui_sel_listPtr == selectionPtr) { /* is first element */
  180.     ui_sel_listPtr        = selectionPtr->nextPtr;
  181.     selectionPtr->nextPtr = ui_sel_freeListPtr;
  182.     ui_sel_freeListPtr    = selectionPtr;
  183.     ui_sel_numberOfSelectedItems -= 1;
  184.     } else { /* second, third, ... element */
  185.     selPtr = ui_sel_listPtr;
  186.     while ((selPtr->nextPtr != selectionPtr) AND
  187.            (selPtr->nextPtr != NULL)) 
  188.         selPtr = selPtr->nextPtr;
  189.  
  190.     if (selPtr->nextPtr == selectionPtr) { /* item was found */
  191.         selPtr->nextPtr       = selectionPtr->nextPtr;
  192.         selectionPtr->nextPtr = ui_sel_freeListPtr;
  193.         ui_sel_freeListPtr    = selectionPtr;
  194.         ui_sel_numberOfSelectedItems -= 1;
  195.     }
  196.     }
  197. }
  198.     
  199.  
  200. /*****************************************************************************
  201.   FUNCTION : ui_sel_getFreeItem
  202.  
  203.   PURPOSE  : looks in the free list for an item. If no one is found, 
  204.              ui_sel_createItem() is called to create a new one.
  205.   RETURNS  : a pointer to a free item or NULL if malloc() fails
  206. *****************************************************************************/
  207.  
  208. static struct SelectionType *ui_sel_getFreeItem (void)
  209.  
  210. {
  211.     struct SelectionType  *selPtr;
  212.  
  213.     if (ui_sel_freeListPtr == NULL) { /* no free item */
  214.     selPtr             = ui_sel_createItem(); /* create a new item */
  215.     } else {
  216.     selPtr             = ui_sel_freeListPtr;
  217.     ui_sel_freeListPtr = selPtr->nextPtr;
  218.     }
  219.     if (selPtr != NULL) {
  220.     /* link it in the list as the first element */
  221.     (*selPtr).nextPtr = ui_sel_listPtr;
  222.     ui_sel_listPtr    = selPtr;
  223.     }
  224.     return (selPtr);
  225. }
  226.     
  227.  
  228. /*****************************************************************************
  229.   FUNCTION : ui_sel_drawBoxes
  230.  
  231.   PURPOSE  : draw outline of all selected units
  232.   RETURNS  :  void
  233.   NOTES    : 
  234.  
  235.   UPDATE   :
  236. *****************************************************************************/
  237.  
  238. void ui_sel_drawBoxes (struct Ui_DisplayType *displayPtr, FlagType scope,
  239.         struct PosType gridPos)
  240.  
  241. {   
  242.     struct PosType  pos1, pos2, pixOffset;
  243.     struct Ui_DisplayType *dPtr;
  244.     struct SelectionType  *selPtr;
  245.  
  246.     if (scope == UI_GLOBAL) {
  247.     for (dPtr = ui_displ_listPtr;
  248.          dPtr != NULL;
  249.          dPtr = dPtr ->nextPtr) 
  250.         ui_sel_drawBoxes(dPtr, UI_LOCAL, gridPos);
  251.     } else { /* UI_LOCAL */
  252.  
  253.     pixOffset.x = displayPtr->gridSize * gridPos.x;
  254.     pixOffset.y = displayPtr->gridSize * gridPos.y;
  255.     
  256.     XSetFunction(ui_display, ui_gc, GXinvert);
  257.     XSetBackground(ui_display, ui_gc, 
  258.                ui_backgroundColor);
  259.     XSetForeground(ui_display, ui_gc, 
  260.                ui_textColor);
  261.     
  262.     if (ui_col_colorDisplay)
  263.         XSetPlaneMask(ui_display, ui_gc, 
  264.               ui_textColor 
  265.               BIT_XOR 
  266.               ui_backgroundColor);
  267.     
  268.     for (selPtr = ui_sel_listPtr;
  269.          selPtr != NULL;
  270.          selPtr = selPtr->nextPtr) {
  271.         
  272.         if ((NOT displayPtr->frozen) AND 
  273.         (displayPtr->subNetNo == ui_currentDisplay->subNetNo)) {
  274.         
  275.         pos1    = ui_utilGridToPix(displayPtr, selPtr->gridPos);
  276.         pos1.x -= ((ui_selectionSize+2) / 2) - pixOffset.x;
  277.         pos1.y -= ((ui_selectionSize+2) / 2) - pixOffset.y;
  278.         pos2.x  = pos1.x + ui_selectionSize+2 - 1;
  279.         pos2.y  = pos1.y + ui_selectionSize+2 - 1;
  280.         ui_xDrawBox(ui_display, displayPtr->drawable, ui_gc, 
  281.                 pos1, pos2);
  282.         }
  283.     }
  284.     }
  285.  
  286.     if (ui_col_colorDisplay)
  287.     XSetPlaneMask(ui_display, ui_gc, AllPlanes);
  288. }
  289.  
  290.  
  291. /*****************************************************************************
  292.   FUNCTION : ui_sel_showSelectedItem
  293.  
  294.   PURPOSE  : show the selection marker of a given unit
  295.   RETURNS  : alteration of the graphic
  296.   NOTES    : When performed a second time the selection marker will disappear,
  297.              because the INVERT raster operation is used to draw the marker.
  298.  
  299.   UPDATE   :
  300. *****************************************************************************/
  301.  
  302. static void ui_sel_showSelectedItem (struct Ui_DisplayType *displayPtr,
  303.         FlagType scope, int unitNo, struct PosType gridPos)
  304.  
  305. {   
  306.     struct PosType  pos1, pos2;
  307.     struct Ui_DisplayType *dPtr;
  308.  
  309.     if (scope == UI_GLOBAL) {
  310.     for (dPtr = ui_displ_listPtr;
  311.          dPtr != NULL;
  312.          dPtr = dPtr ->nextPtr)
  313.         ui_sel_showSelectedItem(dPtr, UI_LOCAL, unitNo, gridPos);
  314.     } else {
  315.     if ((NOT displayPtr->frozen) AND 
  316.         ui_isUnitVisibleInDisplay(displayPtr, unitNo)) { 
  317.         if (ui_col_colorDisplay) {
  318.         XSetFunction(ui_display, ui_gc, GXcopy);
  319.         XSetBackground(ui_display, ui_gc, 
  320.                    ui_backgroundColor);
  321.         XSetForeground(ui_display, ui_gc, 
  322.                    ui_selectionColor);
  323.         } else {
  324.         XSetFunction(ui_display, ui_gc, GXcopyInverted);
  325.         XSetBackground(ui_display, ui_gc, 
  326.                    ui_backgroundColor);
  327.         XSetForeground(ui_display, ui_gc, 
  328.                    ui_textColor);
  329.         }
  330.         
  331.         pos1    = ui_utilGridToPix(displayPtr, gridPos);
  332.         pos1.x -= (ui_selectionSize / 2);
  333.         pos1.y -= (ui_selectionSize / 2);
  334.         pos2.x  = pos1.x + ui_selectionSize - 1;
  335.         pos2.y  = pos1.y + ui_selectionSize - 1;
  336.         /* ui_xDeleteRect(ui_display, displayPtr->drawable, 
  337.            ui_gc, pos1, pos2); */
  338.         if (ui_col_colorDisplay)
  339.         ui_xDeleteRect(ui_display, displayPtr->drawable, ui_gc,
  340.                    pos1, pos2);
  341.         else {
  342.         ui_xDeleteRect(ui_display, displayPtr->drawable, ui_gc,
  343.                    pos1, pos2);
  344.         XSetFunction(ui_display, ui_gc, GXcopy);
  345.         ui_xDrawCrossBox(ui_display, displayPtr->drawable, 
  346.                  ui_gc, pos1, pos2);
  347.         }
  348.     }
  349.     }
  350. }
  351.  
  352.  
  353. /*****************************************************************************
  354.   FUNCTION : ui_sel_doActionSelect
  355.  
  356.   PURPOSE  : This routine does all the action which are needed to perform a
  357.              selection of a given unit.
  358.   RETURNS  : void
  359.   NOTES    : The actions are:
  360.              - set flag and position
  361.          - increase selection counters
  362.          - show the selection in the graohic window
  363.  
  364.   UPDATE   :
  365. *****************************************************************************/
  366.  
  367. static void ui_sel_doActionSelect (struct Ui_DisplayType *displayPtr,
  368.     FlagType scope, struct SelectionType *selPtr, int unitNo,
  369.     struct PosType gridPos)
  370.  
  371. {
  372.     (*selPtr).flags    = UI_SELECTED;
  373.     (*selPtr).unitNo   = unitNo;
  374.     (*selPtr).gridPos  = gridPos;
  375.     (*selPtr).subNetNo = displayPtr->subNetNo;
  376.  
  377.     ui_sel_numberOfSelectedItems += 1;
  378.    
  379.     ui_sel_showSelectedItem(displayPtr, scope, unitNo, gridPos);
  380. }
  381.  
  382.  
  383. /*****************************************************************************
  384.   FUNCTION : ui_sel_selectedOne
  385.  
  386.   PURPOSE  : select a unit at the given position
  387.   RETURNS  : alteration of the selection list
  388.   NOTES    : If the unit is selected yet, the unit will be still selected
  389.              after calling this routine. If there is no unit, nothing will
  390.          be made.
  391.  
  392.   UPDATE   :
  393. *****************************************************************************/
  394.  
  395. void ui_sel_selectOne (struct Ui_DisplayType *displayPtr, FlagType scope, 
  396.         int unitNo, struct PosType gridPos)
  397.  
  398. {
  399.     struct SelectionType  *selPtr;
  400.     char   buf[80];
  401.  
  402.     selPtr = ui_sel_lookForItem(unitNo);  /* already an item ? */    
  403.     if (selPtr != NULL) { /* there is already an item */
  404.     if (ui_utilIsNotSet((*selPtr).flags, UI_SELECTED)) {
  405.         /* select only, if still not selected; else do nothing */
  406.         if (ui_isUnitVisibleInAnyDisplay(selPtr->unitNo)) {
  407.         ui_sel_doActionSelect(displayPtr, scope, selPtr, unitNo, gridPos);
  408.         } else {
  409.         ui_sel_freeItem(selPtr);
  410.         }
  411.     }
  412.     } else { /* no item at gridPos found */
  413.     if (ui_isUnitVisibleInAnyDisplay(unitNo)) {
  414.         if ((selPtr = ui_sel_getFreeItem()) == NULL) {
  415.         sprintf(buf,"No memory left to select unit %d!",unitNo);
  416.         ui_confirmOk(buf);
  417.         } else
  418.         ui_sel_doActionSelect(displayPtr, scope, selPtr, 
  419.                       unitNo, gridPos);
  420.     }
  421.     }
  422. }
  423.  
  424.  
  425. /*****************************************************************************
  426.   FUNCTION : ui_sel_unselectedOne
  427.  
  428.   PURPOSE  : unselect a unit at the given position
  429.   RETURNS  : alteration of the selection list
  430.   NOTES    : see ui_sel_selectOne()
  431.  
  432.   UPDATE   : 
  433. *****************************************************************************/ 
  434.  
  435. void ui_sel_unselectOne (struct Ui_DisplayType *displayPtr, FlagType scope,
  436.         int unitNo, struct PosType gridPos)
  437.  
  438. {
  439.     struct SelectionType  *selPtr;
  440.  
  441.     selPtr = ui_sel_lookForItem(unitNo); /* Is there an item ? */
  442.     if (selPtr != NULL) { /* an item with this position exists */
  443.     if (ui_utilIsSet((*selPtr).flags, UI_SELECTED)) {
  444.         /* And is still selected */
  445.         (*selPtr).flags = UI_NO_FLAG;
  446.         ui_sel_freeItem(selPtr);
  447.         ui_net_drawUnit(displayPtr, scope, unitNo, UI_DRAW);
  448.     }
  449.     }
  450. }
  451.  
  452.  
  453. /*****************************************************************************
  454.   FUNCTION : ui_sel_selectRect
  455.  
  456.   PURPOSE  : select all units within a rectangle area determined by the upper
  457.              left and bottom right positions (inclusive border!).
  458.   RETURNS  : alteration of the selection list
  459.   NOTES    :
  460.  
  461.   UPDATE   :
  462. *****************************************************************************/
  463.  
  464. void ui_sel_selectRect (struct Ui_DisplayType *displayPtr, FlagType scope,
  465.         struct PosType upperLeft, struct PosType lowerRight)
  466.  
  467. {
  468.     struct PosType  gridPos;
  469.     int             unitNo;
  470.  
  471.     for (unitNo = krui_getFirstUnit();
  472.      unitNo > 0;
  473.      unitNo = krui_getNextUnit()) {
  474.     krui_getUnitPosition(unitNo, &gridPos);
  475.     if ((displayPtr->subNetNo == krui_getUnitSubnetNo(unitNo)) AND
  476.         (gridPos.x >= upperLeft.x) AND
  477.         (gridPos.x <= lowerRight.x) AND
  478.         (gridPos.y >= upperLeft.y) AND
  479.         (gridPos.y <= lowerRight.y))
  480.         /* the unit is in this area */
  481.         ui_sel_selectOne(displayPtr, scope, unitNo, gridPos);
  482.     }
  483.     ui_sel_msgNumber(); 
  484. }
  485.  
  486.  
  487. /*****************************************************************************
  488.   FUNCTION : ui_sel_unselectRect
  489.  
  490.   PURPOSE  : unselect all units within a rectangle area determined by the upper
  491.              left and bottom right positions (inclusive border!).
  492.   RETURNS  : alteration of the selection list
  493.   NOTES    :
  494.  
  495.   UPDATE   :
  496. *****************************************************************************/
  497.  
  498. void ui_sel_unselectRect (struct Ui_DisplayType *displayPtr, FlagType scope, 
  499.         struct PosType upperLeft, struct PosType lowerRight)
  500.  
  501. {
  502.     struct PosType  gridPos;
  503.     int             unitNo;
  504.  
  505.     for (unitNo = krui_getFirstUnit();
  506.      unitNo > 0;
  507.      unitNo = krui_getNextUnit()) {
  508.     krui_getUnitPosition(unitNo, &gridPos);
  509.     if ((displayPtr->subNetNo == krui_getUnitSubnetNo(unitNo)) AND
  510.         (gridPos.x >= upperLeft.x) AND
  511.         (gridPos.x <= lowerRight.x) AND
  512.         (gridPos.y >= upperLeft.y) AND
  513.         (gridPos.y <= lowerRight.y))
  514.         /* the unit is in this area */
  515.         ui_sel_unselectOne(displayPtr, scope, unitNo, gridPos);
  516.     }
  517.     ui_sel_msgNumber(); 
  518. }
  519.  
  520.  
  521. /*****************************************************************************
  522.   FUNCTION : ui_sel_reshowItems
  523.  
  524.   PURPOSE  : show (and erase!) the selection markers of all selected units.
  525.   RETURNS  : alteration of the graphic
  526.   NOTES    : When called a second time, this routine erases all markers, cause
  527.              they were drawn with the XOR raster operation.
  528.  
  529.   UPDATE   :
  530. *****************************************************************************/
  531.  
  532. void ui_sel_reshowItems (struct Ui_DisplayType *displayPtr, FlagType scope)
  533.  
  534. {
  535.     struct SelectionType  *selPtr;
  536.  
  537.     selPtr = ui_sel_listPtr;
  538.     /* reshow all selected items */
  539.     while ((selPtr != NULL)) {
  540.     if (ui_utilIsSet((*selPtr).flags,UI_SELECTED))
  541.         ui_sel_showSelectedItem(displayPtr, scope, 
  542.                     (*selPtr).unitNo, (*selPtr).gridPos);
  543.     selPtr = (*selPtr).nextPtr;
  544.     }
  545.     ui_sel_msgNumber(); 
  546. }
  547.  
  548.  
  549. /*****************************************************************************
  550.   FUNCTION : ui_sel_checkList
  551.  
  552.   PURPOSE  : checks, whether selected units should be unselected because of
  553.              1) layers are changed (unit is unvisible now)
  554.          2) no display with the specified subnetNo exist.
  555.   RETURNS  : alteration of the graphic
  556.   NOTES    : 
  557.  
  558.   UPDATE   :
  559. *****************************************************************************/
  560.  
  561. void ui_sel_checkList (struct Ui_DisplayType *displayPtr, FlagType scope)
  562.  
  563. {
  564.     struct SelectionType  *selPtr, *tmpPtr;
  565.     struct Ui_DisplayType *dPtr;
  566.  
  567.     dPtr = ui_displ_listPtr;
  568.     while (dPtr != NULL) {
  569.     selPtr = ui_sel_listPtr;
  570.     while ((selPtr != NULL)) {
  571.         if (NOT ui_isUnitVisibleInDisplay(dPtr, selPtr->unitNo)) {
  572.         /* now this selected unit is unvisible !! */
  573.         /* hide selection marker */
  574.         ui_sel_showSelectedItem(dPtr, UI_LOCAL, 
  575.                     selPtr->unitNo, selPtr->gridPos);
  576.         tmpPtr = selPtr;
  577.         selPtr = selPtr->nextPtr;
  578.         ui_sel_freeItem(tmpPtr);
  579.         } else
  580.         selPtr = selPtr->nextPtr;
  581.     }
  582.     dPtr = dPtr->nextPtr;
  583.     }
  584.     ui_sel_msgNumber();
  585. }
  586.  
  587.  
  588. /*****************************************************************************
  589.   FUNCTION : ui_sel_unselectAll
  590.  
  591.   PURPOSE  : unselect all units.
  592.   RETURNS  : alteration of the selection list and the graphic
  593.   NOTES    : The markers must be visible when calling this routine!
  594.  
  595.   UPDATE   :
  596. *****************************************************************************/
  597.  
  598. void ui_sel_unselectAll (struct Ui_DisplayType *displayPtr, FlagType scope)
  599.  
  600. {
  601.     while (ui_sel_listPtr != NULL) {
  602.     if (ui_utilIsSet(ui_sel_listPtr->flags, UI_SELECTED)) {
  603.         ui_sel_unselectOne(displayPtr, scope, ui_sel_listPtr->unitNo,
  604.                    ui_sel_listPtr->gridPos);
  605.     } else
  606.         ui_sel_freeItem(ui_sel_listPtr);
  607.     }
  608.     ui_sel_msgNumber(); 
  609. }
  610.     
  611.  
  612. /*****************************************************************************
  613.   FUNCTION : ui_sel_resetList
  614.  
  615.   PURPOSE  : reset of the selection list for the specified mode (UI_EDITOR
  616.              or UI_SIMULATOR). No graphic update is made, so all markers must
  617.          be unvisible or the network will be dran with 
  618.          ui_net_completeRefresh().
  619.   RETURNS  : alteration of the selection list
  620.   NOTES    :
  621.  
  622.   UPDATE   :
  623. *****************************************************************************/
  624.  
  625. void ui_sel_resetList (void)
  626.  
  627. {
  628.     while (ui_sel_listPtr != NULL) {
  629.     ui_sel_listPtr->flags = UI_NO_FLAG;
  630.     ui_sel_freeItem(ui_sel_listPtr);
  631.     }
  632.     ui_sel_msgNumber(); 
  633. }
  634.  
  635.  
  636.  
  637.  
  638.  
  639.  
  640.  
  641.  
  642.  
  643. /* end of file */
  644. /* lines: 678 */
  645.